Python Veri Ambarı: OLAP Sistem Tasarımına Kapsamlı Bir Rehber

Günümüzün veri odaklı dünyasında, büyük miktarda bilgiyi hızla analiz edebilme yeteneği sadece bir rekabet avantajı değil, aynı zamanda bir zorunluluktur. Dünya çapındaki işletmeler, pazar trendlerini anlamak, operasyonları optimize etmek ve stratejik kararlar almak için sağlam analitiklere güvenmektedir. Bu analitik yeteneğin kalbinde iki temel kavram yatmaktadır: Veri Ambarı (DWH) ve Çevrimiçi Analitik İşleme (OLAP) sistemleri.

Geleneksel olarak, bu sistemleri oluşturmak özel, genellikle tescilli ve pahalı yazılımlar gerektiriyordu. Ancak, açık kaynak teknolojilerinin yükselişi, veri mühendisliğini demokratikleştirdi. Bu atılımın öncüsü, uçtan uca veri çözümleri oluşturmak için onu olağanüstü bir seçim haline getiren zengin bir ekosisteme sahip çok yönlü ve güçlü bir dil olan Python'dur. Bu kılavuz, veri mühendisleri, mimarlar ve geliştiricilerden oluşan küresel bir kitle için uyarlanmış Python yığınını kullanarak veri ambarı ve OLAP sistemleri tasarlama ve uygulama konusunda kapsamlı bir yol haritası sunar.

Bölüm 1: İş Zekasının Temel Taşları - DWH ve OLAP

Python koduna dalmadan önce, mimari prensipleri anlamak çok önemlidir. Yaygın bir hata, doğrudan operasyonel veritabanlarında analiz yapmaya çalışmaktır, bu da kötü performansa ve yanlış içgörülere yol açabilir. Veri ambarları ve OLAP'ın çözmek için tasarlandığı sorun budur.

Veri Ambarı (DWH) Nedir?

Veri ambarı, bir veya daha fazla farklı kaynaktan entegre edilmiş verileri depolayan merkezi bir depodur. Birincil amacı, iş zekası (BI) faaliyetlerini, özellikle analitiği ve raporlamayı desteklemektir. Bunu, bir kuruluşun geçmiş verileri için tek gerçeklik kaynağı olarak düşünün.

Günlük uygulamalara (örneğin, bir e-ticaret ödeme sistemi veya bir bankanın işlem defteri) güç veren bir Çevrimiçi İşlem İşleme (OLTP) veritabanıyla tam bir tezat oluşturur. İşte hızlı bir karşılaştırma:

• İş Yükü: OLTP sistemleri çok sayıda küçük, hızlı işlemi (okuma, ekleme, güncelleme) işler. DWH'ler, milyonlarca kaydı tarayan daha az sayıda karmaşık, uzun süren sorgu için optimize edilmiştir (okuma ağırlıklı).
• Veri Yapısı: OLTP veritabanları, veri bütünlüğünü sağlamak ve yedekliliği önlemek için yüksek oranda normalleştirilmiştir. DWH'ler, analitik sorguları basitleştirmek ve hızlandırmak için genellikle denormalize edilir.
• Amaç: OLTP işi yürütmek içindir. DWH işi analiz etmek içindir.

İyi tasarlanmış bir DWH, genellikle öncü Bill Inmon'a atfedilen dört temel özellikle karakterize edilir:

• Konu Odaklı: Veriler, uygulama süreçlerinden ziyade, 'Müşteri', 'Ürün' veya 'Satış' gibi işletmenin ana konuları etrafında düzenlenir.
• Entegre: Veriler çeşitli kaynaklardan toplanır ve tutarlı bir biçimde entegre edilir. Örneğin, 'ABD', 'Amerika Birleşik Devletleri' ve 'A.B.D.', tek bir 'Amerika Birleşik Devletleri' girdisine standartlaştırılabilir.
• Zamana Bağlı: Ambardaki veriler, uzun bir zaman dilimi (örneğin, 5-10 yıl) boyunca bilgileri temsil eder ve geçmiş analizi ve trend tanımlamasına olanak tanır.
• Uçucu Olmayan: Veriler ambara yüklendikten sonra, nadiren, hatta hiç güncellenmez veya silinmez. Geçmiş olayların kalıcı bir kaydı haline gelir.

OLAP (Çevrimiçi Analitik İşleme) Nedir?

DWH geçmiş veri kitaplığıysa, OLAP onu keşfetmenizi sağlayan güçlü arama motoru ve analitik aracıdır. OLAP, kullanıcıların OLAP küpleri olarak bilinen çok boyutlu görünümlerde özetlenmiş bilgileri hızla analiz etmelerini sağlayan bir yazılım teknolojisi kategorisidir.

OLAP küpü, OLAP'ın kavramsal kalbidir. Zorunlu olarak fiziksel bir veri yapısı değil, verileri modellemenin ve görselleştirmenin bir yoludur. Bir küp şunlardan oluşur:

• Ölçüler: Bunlar, 'Gelir', 'Satılan Miktar' veya 'Kâr' gibi analiz etmek istediğiniz nicel, sayısal veri noktalarıdır.
• Boyutlar: Bunlar, ölçüleri tanımlayan ve bağlam sağlayan kategorik özelliklerdir. Yaygın boyutlar arasında 'Zaman' (Yıl, Çeyrek, Ay), 'Coğrafya' (Ülke, Bölge, Şehir) ve 'Ürün' (Kategori, Marka, SKU) bulunur.

Satış verilerinin bir küpünü hayal edin. Farklı boyutlarda toplam gelire (ölçü) bakabilirsiniz. OLAP ile bu küp üzerinde inanılmaz bir hızda güçlü işlemler gerçekleştirebilirsiniz:

• Dilimleme: Bir boyut için tek bir değer seçerek küpün boyutsallığını azaltma. Örnek: Yalnızca '2023'ün 4. Çeyreği' için satış verilerini görüntüleme.
• Doğrama: Birden çok boyut için bir değer aralığı belirterek bir alt küp seçme. Örnek: 'Elektronik' ve 'Giyim' (Ürün boyutu) için 'Avrupa' ve 'Asya'daki (Coğrafya boyutu) satışları görüntüleme.
• Detaya İndirme / Detaydan Çıkma: Bir boyut içindeki ayrıntı düzeylerinde gezinme. Detaya inme, daha yüksek düzeydeki özetlerden daha düşük düzeydeki ayrıntılara (örneğin, 'Yıl'dan 'Çeyrek'e' ve 'Ay'a) geçer. Detaydan çıkma (veya toplama) bunun tersidir.
• Pivot: Verilerin yeni bir görünümünü elde etmek için küpün eksenlerini döndürme. Örnek: Hangi bölgelerin hangi ürünleri satın aldığını görmek için 'Ürün' ve 'Coğrafya' eksenlerini değiştirmek, bunun yerine hangi ürünlerin hangi bölgelerde satıldığını görmek.

OLAP Sistem Türleri

OLAP sistemleri için üç ana mimari model vardır:

1. MOLAP (Çok Boyutlu OLAP): Bu, "klasik" küp modelidir. Veriler DWH'den çıkarılır ve tescilli, çok boyutlu bir veritabanında önceden toplanır. Artıları: Tüm cevaplar önceden hesaplandığı için son derece hızlı sorgu performansı. Eksileri: Önceden toplanmış hücrelerin sayısı çok büyük olabileceğinden ve öngörülmeyen bir soru sormanız gerekirse daha az esnek olabileceğinden bir "veri patlamasına" yol açabilir.
2. ROLAP (İlişkisel OLAP): Bu model, verileri ilişkisel bir veritabanında (tipik olarak DWH'nin kendisi) tutar ve OLAP sorgularını standart SQL'e çevirmek için gelişmiş bir meta veri katmanı kullanır. Artıları: Modern ilişkisel veritabanlarının gücünden yararlandığı için son derece ölçeklenebilir ve daha ayrıntılı, gerçek zamanlı verileri sorgulayabilir. Eksileri: Toplamalar anında gerçekleştirildiğinden sorgu performansı MOLAP'tan daha yavaş olabilir.
3. HOLAP (Hibrit OLAP): Bu yaklaşım, her iki dünyanın da en iyilerini birleştirmeye çalışır. Yüksek düzeyde toplanmış verileri hız için MOLAP tarzı bir küpte depolar ve detaylı verileri detaylı analiz için ROLAP ilişkisel veritabanında tutar.

Python ile oluşturulmuş modern veri yığınları için, çizgiler bulanıklaştı. İnanılmaz derecede hızlı sütunsal veritabanlarının yükselişiyle, ROLAP modeli baskın ve son derece etkili hale geldi ve genellikle geleneksel MOLAP sistemleriyle rekabet eden performansı katılık olmadan sunuyor.

Bölüm 2: Veri Ambarı İçin Python Ekosistemi

Geleneksel olarak kurumsal BI platformlarının hakim olduğu bir görev için neden Python'u seçmelisiniz? Cevap, esnekliğinde, güçlü ekosisteminde ve tüm veri yaşam döngüsünü birleştirme yeteneğinde yatıyor.

Neden Python?

• Birleşik Bir Dil: Python'u veri çıkarma (ETL), dönüştürme, yükleme, düzenleme, analiz, makine öğrenimi ve API geliştirme için kullanabilirsiniz. Bu, karmaşıklığı ve farklı diller ve araçlar arasında bağlam değiştirmeye duyulan ihtiyacı azaltır.
• Geniş Kütüphane Ekosistemi: Python, veri manipülasyonundan (Pandas, Dask) veritabanı etkileşimine (SQLAlchemy) ve iş akışı yönetimine (Airflow, Prefect) kadar sürecin her adımı için olgun, savaşta test edilmiş kütüphanelere sahiptir.
• Satıcıdan Bağımsız: Python açık kaynaktır ve her şeye bağlanır. Verileriniz bir PostgreSQL veritabanında, bir Snowflake ambarında, bir S3 veri gölünde veya bir Google Etablosunda yaşıyor olsun, ona erişmek için bir Python kütüphanesi vardır.
• Ölçeklenebilirlik: Python çözümleri, bir dizüstü bilgisayarda çalışan basit bir betikten, Dask veya Spark (PySpark aracılığıyla) gibi araçları kullanarak bir bulut kümesinde petabaytlarca veri işleyen dağıtılmış bir sisteme ölçeklenebilir.

Veri Ambarı Yığını İçin Temel Python Kütüphaneleri

Tipik bir Python tabanlı veri ambarı çözümü, tek bir ürün değil, güçlü kütüphanelerden oluşan bir koleksiyondur. İşte temel bilgiler:

ETL/ELT (Çıkarma, Dönüştürme, Yükleme) İçin

• Pandas: Python'da bellek içi veri manipülasyonu için fiili standart. Küçük ila orta ölçekli veri kümelerini (birkaç gigabayta kadar) işlemek için mükemmeldir. DataFrame nesnesi, verileri temizlemek, dönüştürmek ve analiz etmek için sezgisel ve güçlüdür.
• Dask: Python analitiğinizi ölçeklendiren paralel bir bilgi işlem kütüphanesi. Dask, Pandas API'sini taklit eden ancak belleğe sığmayan veri kümelerinde, bunları parçalara ayırarak ve birden çok çekirdek veya makinede paralel olarak işleyerek çalışabilen paralel bir DataFrame nesnesi sağlar.
• SQLAlchemy: Python için önde gelen SQL araç seti ve Nesne İlişkisel Eşleyici (ORM). SQLite'tan BigQuery veya Redshift gibi kurumsal sınıf ambarlara kadar neredeyse herhangi bir SQL veritabanına bağlanmak için tutarlı, yüksek düzeyli bir API sağlar.
• İş Akışı Orkestratörleri (Airflow, Prefect, Dagster): Bir veri ambarı tek bir betik üzerine kurulmamıştır. Bir dizi bağımlı görevdir (A'dan çıkar, B'yi dönüştür, C'ye yükle, D'yi kontrol et). Orkestratörler, bu iş akışlarını Yönlendirilmiş Döngüsel Olmayan Grafikler (DAG'ler) olarak tanımlamanıza, planlamanıza, izlemenize ve sağlamlıkla yeniden denemenize olanak tanır.

Veri Depolama ve İşleme İçin

• Bulut DWH Bağlayıcıları: snowflake-connector-python, google-cloud-bigquery ve psycopg2 (Redshift ve PostgreSQL için) gibi kütüphaneler, büyük bulut veri ambarlarıyla sorunsuz etkileşim sağlar.
• PyArrow: Sütunsal veri formatlarıyla çalışmak için çok önemli bir kütüphane. Standartlaştırılmış bir bellek içi format sağlar ve sistemler arasında yüksek hızlı veri aktarımını sağlar. Parquet gibi formatlarla verimli etkileşimlerin arkasındaki motordur.
• Modern Göl Evi Kütüphaneleri: Gelişmiş kurulumlar için, deltalake, py-iceberg gibi kütüphaneler ve Spark kullanıcıları için PySpark'ın bu formatlar için yerel desteği, Python'un bir ambarın temeli olarak hizmet veren güvenilir, işlemsel veri gölleri oluşturmasına olanak tanır.

Bölüm 3: Python ile Bir OLAP Sistemi Tasarlama

Şimdi teoriden pratiğe geçelim. İşte analitik sisteminizi tasarlamak için adım adım bir kılavuz.

Adım 1: Analitik için Veri Modelleme

İyi bir OLAP sisteminin temeli, veri modelidir. Amaç, verileri hızlı, sezgisel sorgulama için yapılandırmaktır. En yaygın ve etkili modeller yıldız şeması ve varyantı olan kar tanesi şemasıdır.

Yıldız Şeması ve Kar Tanesi Şeması

Yıldız Şeması, veri ambarları için en yaygın kullanılan yapıdır. Şunlardan oluşur:

• Merkezi bir Gerçek Tablo: Boyut tablolarına ölçüleri (analiz etmek istediğiniz sayılar) ve yabancı anahtarları içerir.
• Çeşitli Boyut Tabloları: Her boyut tablosu, tek bir anahtarla gerçek tablosuna birleştirilir ve açıklayıcı özellikler içerir. Bu tablolar, basitlik ve hız için yüksek oranda denormalize edilmiştir.

Örnek: DateKey, ProductKey, StoreKey, QuantitySold ve TotalRevenue gibi sütunlara sahip bir FactSales tablosu. DimDate, DimProduct ve DimStore tablolarıyla çevrelenmiş olurdu.

Kar Tanesi Şeması, boyut tablolarının birden çok ilgili tabloya normalleştirildiği yıldız şemasının bir uzantısıdır. Örneğin, DimProduct tablosu DimProduct, DimBrand ve DimCategory tablolarına ayrılabilir.

Öneri: Bir Yıldız Şeması ile başlayın. Sorgular daha basittir (daha az birleştirme) ve modern sütunsal veritabanları geniş, denormalize edilmiş tabloları işlemekte o kadar verimlidir ki, kar tanesi şemalarının depolama avantajları genellikle ek birleştirmelerin performans maliyetine kıyasla ihmal edilebilir düzeydedir.

Adım 2: Python'da ETL/ELT Hattını Oluşturma

ETL süreci, veri ambarınızı besleyen omurgadır. Verileri kaynak sistemlerden çıkarmayı, temiz ve tutarlı bir formata dönüştürmeyi ve analitik modelinize yüklemeyi içerir.

Pandas kullanarak basit bir Python betiğiyle gösterelim. Ham siparişlerin bir kaynak CSV dosyasına sahip olduğumuzu hayal edin.

# Python ve Pandas kullanılarak basitleştirilmiş bir ETL örneği

import pandas as pd

# --- ÇIKAR --- 
print("Ham sipariş verileri çıkarılıyor...")
source_df = pd.read_csv('raw_orders.csv')

# --- DÖNÜŞTÜR --- 
print("Veriler dönüştürülüyor...")

# 1. Verileri temizle
source_df['order_date'] = pd.to_datetime(source_df['order_date'])
source_df['product_price'] = pd.to_numeric(source_df['product_price'], errors='coerce')
source_df.dropna(inplace=True)

# 2. Verileri zenginleştir - Ayrı bir Tarih Boyutu oluştur
dim_date = pd.DataFrame({
    'DateKey': source_df['order_date'].dt.strftime('%Y%m%d').astype(int),
    'Date': source_df['order_date'].dt.date,
    'Year': source_df['order_date'].dt.year,
    'Quarter': source_df['order_date'].dt.quarter,
    'Month': source_df['order_date'].dt.month,
    'DayOfWeek': source_df['order_date'].dt.day_name()
}).drop_duplicates().reset_index(drop=True)

# 3. Bir Ürün Boyutu oluştur
dim_product = source_df[['product_id', 'product_name', 'category']].copy()
dim_product.rename(columns={'product_id': 'ProductKey'}, inplace=True)
dim_product.drop_duplicates(inplace=True).reset_index(drop=True)

# 4. Gerçek Tabloyu oluştur
fact_sales = source_df.merge(dim_date, left_on=source_df['order_date'].dt.date, right_on='Date')\
                      .merge(dim_product, left_on='product_id', right_on='ProductKey')

fact_sales = fact_sales[['DateKey', 'ProductKey', 'order_id', 'quantity', 'product_price']]
fact_sales['TotalRevenue'] = fact_sales['quantity'] * fact_sales['product_price']
fact_sales.rename(columns={'order_id': 'OrderCount'}, inplace=True)

# İstenilen ayrıntı düzeyine toplama
fact_sales = fact_sales.groupby(['DateKey', 'ProductKey']).agg(
    TotalRevenue=('TotalRevenue', 'sum'),
    TotalQuantity=('quantity', 'sum')
).reset_index()

# --- YÜKLE ---
print("Veriler hedef depolamaya yükleniyor...")
# Bu örnek için, son derece verimli bir sütunsal format olan Parquet dosyalarına kaydedeceğiz
dim_date.to_parquet('warehouse/dim_date.parquet')
dim_product.to_parquet('warehouse/dim_product.parquet')
fact_sales.to_parquet('warehouse/fact_sales.parquet')

print("ETL süreci tamamlandı!")

Bu basit betik, temel mantığı gösterir. Gerçek dünyadaki bir senaryoda, bu mantığı işlevlere sarmalar ve Airflow gibi bir düzenleyici ile yürütülmesini yönetirsiniz.

Adım 3: OLAP Motorunu Seçme ve Uygulama

Verileriniz modellendi ve yüklendiğinde, OLAP işlemlerini gerçekleştirmek için bir motora ihtiyacınız vardır. Python dünyasında, öncelikle ROLAP yaklaşımını izleyen birkaç güçlü seçeneğiniz vardır.

A Yaklaşımı: Hafif Güç Merkezi - DuckDB

DuckDB, Python ile inanılmaz derecede hızlı ve kullanımı kolay olan bir işlem içi analitik veritabanıdır. SQL kullanarak doğrudan Pandas DataFrame'lerini veya Parquet dosyalarını sorgulayabilir. Küçük ila orta ölçekli OLAP sistemleri, prototipler ve yerel geliştirme için mükemmel bir seçimdir.

Yüksek performanslı bir ROLAP motoru görevi görür. Standart SQL yazarsınız ve DuckDB, veri dosyalarınız üzerinde son derece hızlı bir şekilde yürütür.

import duckdb

# Bir bellek içi veritabanına veya bir dosyaya bağlanın
con = duckdb.connect(database=':memory:', read_only=False)

# Daha önce oluşturduğumuz Parquet dosyalarını doğrudan sorgulayın
# DuckDB şemayı otomatik olarak anlar
result = con.execute("""
SELECT
    p.category,
    d.Year,
    SUM(f.TotalRevenue) AS AnnualRevenue
FROM 'warehouse/fact_sales.parquet' AS f
JOIN 'warehouse/dim_product.parquet' AS p ON f.ProductKey = p.ProductKey
JOIN 'warehouse/dim_date.parquet' AS d ON f.DateKey = d.DateKey
WHERE p.category = 'Electronics'
GROUP BY p.category, d.Year
ORDER BY d.Year;
""").fetchdf() # fetchdf() bir Pandas DataFrame döndürür

print(result)

B Yaklaşımı: Bulut Ölçekli Titanlar - Snowflake, BigQuery, Redshift

Büyük ölçekli kurumsal sistemler için, bir bulut veri ambarı standart seçimdir. Python, bu platformlarla sorunsuz bir şekilde bütünleşir. ETL süreciniz verileri bulut DWH'ye yükler ve Python uygulamanız (örneğin, bir BI panosu veya bir Jupyter not defteri) onu sorgular.

Mantık DuckDB ile aynı kalır, ancak bağlantı ve ölçek farklıdır.

import snowflake.connector

# Snowflake'e bağlanma ve bir sorgu çalıştırma örneği
conn = snowflake.connector.connect(
    user='your_user',
    password='your_password',
    account='your_account_identifier'
)

cursor = conn.cursor()

try:
    cursor.execute("USE WAREHOUSE MY_WH;")
    cursor.execute("USE DATABASE MY_DB;")
    cursor.execute("""
        SELECT category, YEAR(date), SUM(total_revenue)
        FROM fact_sales 
        JOIN dim_product ON ...
        JOIN dim_date ON ...
        GROUP BY 1, 2;
    """)
    # Gerektiğinde sonuçları getirin
    for row in cursor:
        print(row)
finally:
    cursor.close()
    conn.close()

C Yaklaşımı: Gerçek Zamanlı Uzmanlar - Apache Druid veya ClickHouse

Büyük, akış verisi kümelerinde (gerçek zamanlı kullanıcı analitiği gibi) saniyenin altında sorgu gecikmesi gerektiren kullanım durumları için, Druid veya ClickHouse gibi özel veritabanları mükemmel seçimlerdir. OLAP iş yükleri için tasarlanmış sütunsal veritabanlarıdır. Python, verileri bunlara aktarmak ve ilgili istemci kütüphaneleri veya HTTP API'leri aracılığıyla sorgulamak için kullanılır.

Bölüm 4: Pratik Bir Örnek - Mini Bir OLAP Sistemi Oluşturma

Şimdi bu kavramları mini bir projede birleştirelim: etkileşimli bir satış panosu. Bu, basitleştirilmiş olsa da eksiksiz bir Python tabanlı OLAP sistemini gösterir.

Yığınımız:

• ETL: Python ve Pandas
• Veri Depolama: Parquet dosyaları
• OLAP Motoru: DuckDB
• Pano: Streamlit (veri bilimi için güzel, etkileşimli web uygulamaları oluşturmaya yönelik açık kaynaklı bir Python kütüphanesi)

İlk olarak, `warehouse/` dizininde Parquet dosyalarını oluşturmak için Bölüm 3'teki ETL betiğini çalıştırın.

Ardından, pano uygulama dosyasını oluşturun, `app.py`:

# app.py - Basit Bir Etkileşimli Satış Panosu

import streamlit as st
import duckdb
import pandas as pd
import plotly.express as px

# --- Sayfa Yapılandırması ---
st.set_page_config(layout="wide", page_title="Küresel Satış Panosu")
st.title("Etkileşimli Satış OLAP Panosu")

# --- DuckDB'ye Bağlan ---
# Bu, Parquet dosyalarımızı doğrudan sorgulayacaktır
con = duckdb.connect(database=':memory:', read_only=True)

# --- Filtreler İçin Boyut Verilerini Yükle ---
@st.cache_data
def load_dimensions():
    products = con.execute("SELECT DISTINCT category FROM 'warehouse/dim_product.parquet'").fetchdf()
    years = con.execute("SELECT DISTINCT Year FROM 'warehouse/dim_date.parquet' ORDER BY Year").fetchdf()
    return products['category'].tolist(), years['Year'].tolist()

categories, years = load_dimensions()

# --- Filtreler İçin Kenar Çubuğu (Dilimleme ve Doğrama!) ---
st.sidebar.header("OLAP Filtreleri")

selected_categories = st.sidebar.multiselect(
    'Ürün Kategorilerini Seçin',
    options=categories,
    default=categories
)

selected_year = st.sidebar.selectbox(
    'Yıl Seçin',
    options=years,
    index=len(years)-1 # Varsayılan olarak en son yıla ayarla
)

# --- OLAP Sorgusunu Dinamik Olarak Oluşturun ---
if not selected_categories:
    st.warning("Lütfen en az bir kategori seçin.")
    st.stop()

query = f"""
SELECT
    d.Month,
    d.MonthName, -- MonthName'in DimDate'te bulunduğunu varsayarsak
    p.category,
    SUM(f.TotalRevenue) AS Revenue
FROM 'warehouse/fact_sales.parquet' AS f
JOIN 'warehouse/dim_product.parquet' AS p ON f.ProductKey = p.ProductKey
JOIN 'warehouse/dim_date.parquet' AS d ON f.DateKey = d.DateKey
WHERE d.Year = {selected_year}
  AND p.category IN ({str(selected_categories)[1:-1]})
GROUP BY d.Month, d.MonthName, p.category
ORDER BY d.Month;
"""

# --- Sorguyu Yürütün ve Sonuçları Görüntüleyin ---
@st.cache_data
def run_query(_query):
    return con.execute(_query).fetchdf()

results_df = run_query(query)

if results_df.empty:
    st.info(f"{selected_year} yılında seçilen filtreler için veri bulunamadı.")
else:
    # --- Ana Pano Görselleri ---
    col1, col2 = st.columns(2)

    with col1:
        st.subheader(f"{selected_year} için Aylık Gelir")
        fig = px.line(
            results_df,
            x='MonthName',
            y='Revenue',
            color='category',
            title='Kategoriye Göre Aylık Gelir'
        )
        st.plotly_chart(fig, use_container_width=True)

    with col2:
        st.subheader("Kategoriye Göre Gelir")
        category_summary = results_df.groupby('category')['Revenue'].sum().reset_index()
        fig_pie = px.pie(
            category_summary,
            names='category',
            values='Revenue',
            title='Kategoriye Göre Toplam Gelir Payı'
        )
        st.plotly_chart(fig_pie, use_container_width=True)

    st.subheader("Ayrıntılı Veriler")
    st.dataframe(results_df)

Bunu çalıştırmak için, kodu `app.py` olarak kaydedin ve terminalinizde `streamlit run app.py` komutunu yürütün. Bu, etkileşimli panonuzla bir web tarayıcısı başlatacaktır. Kenar çubuğundaki filtreler, kullanıcıların OLAP 'dilimleme' ve 'doğrama' işlemlerini gerçekleştirmesine olanak tanır ve pano, DuckDB'yi yeniden sorgulayarak gerçek zamanlı olarak güncellenir.

Bölüm 5: Gelişmiş Konular ve En İyi Uygulamalar

Mini bir projeden bir üretim sistemine geçerken, bu gelişmiş konuları göz önünde bulundurun.

Ölçeklenebilirlik ve Performans

• Büyük ETL için Dask kullanın: Kaynak verileriniz makinenizin RAM'ini aşıyorsa, ETL betiklerinizde Pandas'ı Dask ile değiştirin. API çok benzerdir, ancak Dask çekirdek dışı ve paralel işlemeyi ele alacaktır.
• Sütunsal Depolama Anahtardır: Ambar verilerinizi her zaman Apache Parquet veya ORC gibi sütunsal bir biçimde depolayın. Bu, tipik olarak geniş bir tablodan yalnızca birkaç sütun okuması gereken analitik sorguları önemli ölçüde hızlandırır.
• Bölümleme: Verileri bir veri gölünde (S3 veya yerel bir dosya sistemi gibi) depolarken, verilerinizi tarih gibi sık filtrelenen bir boyuta göre klasörlere ayırın. Örneğin: `warehouse/fact_sales/year=2023/month=12/`. Bu, sorgu motorlarının ilgisiz verileri okumayı atlamasına olanak tanır, bu işleme 'bölümleme temizleme' denir.

Anlamsal Katman

Sisteminiz büyüdükçe, iş mantığının ('Aktif Kullanıcı' veya 'Brüt Kâr' tanımı gibi) birden çok sorguda ve panoda tekrarlandığını göreceksiniz. Bir anlamsal katman, iş ölçütlerinizin ve boyutlarınızın merkezi, tutarlı bir tanımını sağlayarak bunu çözer. dbt (Veri Oluşturma Aracı) gibi araçlar bunun için olağanüstüdür. Kendi başına bir Python aracı olmasa da, dbt mükemmel bir şekilde Python ile düzenlenmiş bir iş akışına entegre olur. Yıldız şemanızı modellemek ve ölçütler tanımlamak için dbt'yi kullanırsınız ve ardından Python, dbt çalıştırmalarını düzenlemek ve elde edilen temiz tablolar üzerinde gelişmiş analizler yapmak için kullanılabilir.

Veri Yönetişimi ve Kalitesi

Bir ambar, içindeki veriler kadar iyidir. Veri kalitesi denetimlerini doğrudan Python ETL hatlarınıza entegre edin. Great Expectations gibi kütüphaneler, verileriniz hakkında 'beklentiler' tanımlamanıza olanak tanır (örneğin, `customer_id` asla null olmamalıdır, `revenue` 0 ile 1.000.000 arasında olmalıdır). ETL göreviniz daha sonra gelen veriler bu sözleşmeleri ihlal ederse başarısız olabilir veya sizi uyarabilir ve kötü verilerin ambarınızı bozmasını önler.

Sonuç: Kod Öncelikli Bir Yaklaşımın Gücü

Python, veri ambarı ve iş zekası alanını temelde değiştirdi. Sıfırdan karmaşık analitik sistemler oluşturmak için esnek, güçlü ve satıcıdan bağımsız bir araç seti sağlar. Pandas, Dask, SQLAlchemy ve DuckDB gibi sınıfının en iyisi kütüphaneleri bir araya getirerek hem ölçeklenebilir hem de sürdürülebilir eksiksiz bir OLAP sistemi oluşturabilirsiniz.

Yolculuk, yıldız şeması gibi veri modelleme ilkelerinin sağlam bir şekilde anlaşılmasıyla başlar. Buradan, verilerinizi şekillendirmek için sağlam ETL hatları oluşturabilir, ölçeğiniz için doğru sorgu motorunu seçebilir ve hatta etkileşimli analitik uygulamaları oluşturabilirsiniz. Genellikle 'Modern Veri Yığını'nın temel bir ilkesi olan bu kod öncelikli yaklaşım, analitik gücünü doğrudan geliştiricilerin ve veri ekiplerinin eline vererek, kuruluşlarının ihtiyaçlarına mükemmel şekilde uyarlanmış sistemler oluşturmalarını sağlar.